import { Data } from '@icon-park/vue-next'

/**
 * 验证电子邮箱格式
 */
function email(value: string) {
  return /^\w+((-\w+)|(\.\w+))*\@[A-Za-z0-9]+((\.|-)[A-Za-z0-9]+)*\.[A-Za-z0-9]+$/.test(
    value
  )
}
// 账号 只能为数字字母 和数字，且长度为8-12位
function accountNumber(value: string) {
  return /^(?![0-9]+$)(?![a-zA-Z]+$)[0-9A-Za-z]{8,12}$/.test(value)
}

// 密码 必须包含大写小写字符 和数字，且长度为8-12位
function passWord(value: string) {
  return /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[\s\S]{8,16}$/.test(value)
}
/**
 * 验证手机格式
 */
export const mobile =(value: string)=> {
  return /^1[23456789]\d{9}$/.test(value)
}

/**
 * 验证URL格式
 */
function url(value: string) {
  return /^((https|http|ftp|rtsp|mms):\/\/)(([0-9a-zA-Z_!~*'().&=+$%-]+: )?[0-9a-zA-Z_!~*'().&=+$%-]+@)?(([0-9]{1,3}.){3}[0-9]{1,3}|([0-9a-zA-Z_!~*'()-]+.)*([0-9a-zA-Z][0-9a-zA-Z-]{0,61})?[0-9a-zA-Z].[a-zA-Z]{2,6})(:[0-9]{1,4})?((\/?)|(\/[0-9a-zA-Z_!~*'().;?:@&=+$,%#-]+)+\/?)$/.test(
    value
  )
}

/**
 * 验证日期格式
 */
function date(value: string) {
  return !/Invalid|NaN/.test(new Date(value).toString())
}

/**
 * 验证ISO类型的日期格式
 */
function dateISO(value: string) {
  return /^\d{4}[\/\-](0?[1-9]|1[012])[\/\-](0?[1-9]|[12][0-9]|3[01])$/.test(
    value
  )
}

/**
 * 验证十进制数字
 */
function number(value: string) {
  return /^(?:-?\d+|-?\d{1,3}(?:,\d{3})+)?(?:\.\d+)?$/.test(value)
}

/**
 * 验证整数
 */
function digits(value: string) {
  return /^\d+$/.test(value)
}

/**
 * 验证身份证号码
 */
function idCard(value: string) {
  return /^[1-9]\d{5}[1-9]\d{3}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{3}([0-9]|X)$/.test(
    value
  )
}

/**
 * 是否车牌号
 */
function carNo(value: string) {
  // 新能源车牌
  const xreg =
    /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领A-Z]{1}[A-Z]{1}(([0-9]{5}[DF]$)|([DF][A-HJ-NP-Z0-9][0-9]{4}$))/
  // 旧车牌
  const creg =
    /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领A-Z]{1}[A-Z]{1}[A-HJ-NP-Z0-9]{4}[A-HJ-NP-Z0-9挂学警港澳]{1}$/
  if (value.length === 7) {
    return creg.test(value)
  } else if (value.length === 8) {
    return xreg.test(value)
  } else {
    return false
  }
}

/**
 * 金额,只允许2位小数
 */
function amount(value: string) {
  //金额，只允许保留两位小数
  return /^[1-9]\d*(,\d{3})*(\.\d{1,2})?$|^0\.\d{1,2}$/.test(value)
}

/**
 * 中文
 */
function chinese(value: string) {
  let reg = /^[\u4e00-\u9fa5]+$/gi
  return reg.test(value)
}

/**
 * 只能输入字母
 */
function letter(value: string) {
  return /^[a-zA-Z]*$/.test(value)
}

/**
 * 只能是字母或者数字
 */
function enOrNum(value: string) {
  //英文或者数字
  let reg = /^[0-9a-zA-Z]*$/g
  return reg.test(value)
}

/**
 * 验证是否包含某个值
 */
function contains(value: Array<any>, param: any) {
  return value.indexOf(param) >= 0
}

/**
 * 验证一个值范围[min, max]
 */
function range(value: number, param: Array<number>) {
  return value >= param[0] && value <= param[1]
}

/**
 * 验证一个长度范围[min, max]
 */
function rangeLength(value: any, param: Array<number>) {
  return value.length >= param[0] && value.length <= param[1]
}

/**
 * 是否固定电话
 */
function landline(value: string) {
  let reg = /^\d{3,4}-\d{7,8}(-\d{3,4})?$/
  return reg.test(value)
}

/**
 * 判断是否为空
 */
function empty(value: any) {
  switch (typeof value) {
    case 'undefined':
      return true
    case 'string':
      if (value.replace(/(^[ \t\n\r]*)|([ \t\n\r]*$)/g, '').length == 0)
        return true
      break
    case 'boolean':
      if (!value) return true
      break
    case 'number':
      // if (0 === value || isNaN(value)) return true;
      if (isNaN(value)) return true
      break
    case 'object':
      if (null === value || value.length === 0) return true
      for (var i in value) {
        return false
      }
      return true
  }
  return false
}

/**
 * 是否json字符串
 */
function jsonString(value: any) {
  if (typeof value == 'string') {
    try {
      var obj = JSON.parse(value)
      if (typeof obj == 'object' && obj) {
        return true
      } else {
        return false
      }
    } catch (e) {
      return false
    }
  }
  return false
}

/**
 * 是否数组
 */
function array(value: any) {
  if (typeof Array.isArray === 'function') {
    return Array.isArray(value)
  } else {
    return Object.prototype.toString.call(value) === '[object Array]'
  }
}

/**
 * 是否对象
 */
function object(value: any) {
  return Object.prototype.toString.call(value) === '[object Object]'
}

/**
 * 是否短信验证码
 */
function code(value: string, len = 6) {
  return new RegExp(`^\\d{${len}}$`).test(value)
}
function onlyNumber(value) {
  value = value.replace(/[^\d.]/g, '') //清除“数字”和“.”以外的字符
  value = value.replace(/\.{2,}/g, '.') //只保留第一个. 清除多余的
  value = value.replace('.', '$#$').replace(/\./g, '').replace('$#$', '.')
  value = value.replace(/^(\-)*(\d+)\.(\d\d).*$/, '$1$2.$3') //只能输入两个小数
  if (value.indexOf('.') < 0 && value != '') {
    //以上已经过滤，此处控制的是如果没有小数点，首位不能为类似于 01、02的金额
    value = parseFloat(value)
  }

  return value
}
// 格式化日期格式
function filterTime(time: number | string) {
  if (time) {
    let mm = null
    let dd = null
    let hh = null
    let min = null
    let ss = null
    var date = new Date(time)
    var y = date.getFullYear()
    var m = date.getMonth() + 1
    var d = date.getDate()
    var h = date.getHours()
    var minute = date.getMinutes()
    var s = date.getSeconds()
    if (m < 10) {
      mm = '0' + m
    } else {
      mm = m
    }
    if (d < 10) {
      dd = '0' + d
    } else {
      dd = d
    }
    if (h < 10) {
      hh = '0' + h
    } else {
      hh = h
    }
    if (minute < 10) {
      min = '0' + minute
    } else {
      min = minute
    }
    if (s < 10) {
      ss = '0' + s
    } else {
      ss = s
    }
    return y + '-' + mm + '-' + dd + ' ' + hh + ':' + min + ':' + ss
  } else {
    return ''
  }
}
// 格式化不包含时间日期格式
function filterDataTime(time: number | string) {
  if (time) {
    let mm = null
    let dd = null
    var date = new Date(time)
    var y = date.getFullYear()
    var m = date.getMonth() + 1
    var d = date.getDate()
    if (m < 10) {
      mm = '0' + m
    } else {
      mm = m
    }
    if (d < 10) {
      dd = '0' + d
    } else {
      dd = d
    }
    return y + '-' + mm + '-' + dd
  } else {
    return ''
  }
}
// 判断日期是几天前
function handleDate(value) {
  let date = new Date(value)
  let diffValue = new Date().getTime() - date.getTime() // 时间差
  let mValue = diffValue / (1000 * 60) // 分
  let hValue = diffValue / (1000 * 60 * 60) // 小时
  let dayValue = diffValue / (1000 * 60 * 60 * 24) // 天
  let result = ''
  if (date.getFullYear() !== new Date().getFullYear()) {
    // 不同年
    result = value
  } else {
    // 同年
    if (dayValue > 6) {
      // 时间差大于一周
      result = value
    } else if (dayValue >= 1 && dayValue <= 6) {
      // 时间差一天之外 一周之内
      result = dayValue.toFixed(0) + '天前'
    } else if (hValue >= 1 && hValue <= 23) {
      result = hValue.toFixed(0) + '小时前'
    } else if (mValue >= 1 && mValue <= 59) {
      result = mValue.toFixed(0) + '分钟前'
    } else {
      result = '刚刚'
    }
  }
  return result
}
function getFileType(fileName: any) {
  // 根据后缀判断文件类型
  let fileSuffix = ''
  // 结果
  let result = null
  try {
    let flieArr = fileName.split('.')
    fileSuffix = flieArr[flieArr.length - 1]
  } catch (err) {
    fileSuffix = ''
  }
  // fileName无后缀返回 false
  if (!fileSuffix) {
    result = false
    return result
  }
  // 图片格式
  let imglist = ['png', 'jpg', 'jpeg', 'bmp', 'gif']
  // 进行图片匹配
  result = imglist.some(function (item) {
    return item == fileSuffix
  })
  if (result) {
    result = 'png'
    return result
  }
  // 匹配txt
  let txtlist = ['txt']
  result = txtlist.some(function (item) {
    return item == fileSuffix
  })
  if (result) {
    result = 'text'
    return result
  }
  // 匹配 excel
  let excelist = ['xls', 'xlsx']
  result = excelist.some(function (item) {
    return item == fileSuffix
  })
  if (result) {
    result = 'excel'
    return result
  }
  // 匹配 word
  let wordlist = ['doc', 'docx']
  result = wordlist.some(function (item) {
    return item == fileSuffix
  })
  if (result) {
    result = 'word'
    return result
  }
  // 匹配 pdf
  let pdflist = ['pdf']
  result = pdflist.some(function (item) {
    return item == fileSuffix
  })
  if (result) {
    result = 'pdf'
    return result
  }
  // 匹配 ppt
  let pptlist = ['ppt']
  result = pptlist.some(function (item) {
    return item == fileSuffix
  })
  if (result) {
    result = 'ppt'
    return result
  }
  // 匹配 视频
  let videolist = ['mp4', 'm2v', 'mkv', 'video']
  result = videolist.some(function (item) {
    return item == fileSuffix
  })
  if (result) {
    result = 'mp4'
    return result
  }
  // 匹配 音频
  let radiolist = ['mp3', 'wav', 'wmv']
  result = radiolist.some(function (item) {
    return item == fileSuffix
  })
  if (result) {
    result = 'mp3'
    return result
  }
  // 压缩包
  let zipList = ['zip', 'rar']
  result = zipList.some(function (item) {
    return item == fileSuffix
  })
  if (result) {
    result = 'zip'
    return result
  }
  // 其他 文件类型
  result = 'other'
  return result
}
//获取浏览器路径参数
function getUrlParameter(param: string) {
  var arrurl = [null, null]
  var reg = new RegExp('(^|&)' + param + '=([^&]*)(&|$)') // 构造一个含有目标参数的正则表达式对象
  var r = window.location.search.substr(1).match(reg) // 匹配目标参数
  if (r != null) {
    arrurl[0] = decodeURIComponent(r[2]) // 返回参数值
    arrurl[1] = r.input
  }
  return arrurl[0]
}
// 获取链接名称
function getUrlName(url: string) {
  var urlList = url.split('/')
  return urlList.slice(urlList.length - 1, urlList.length).toString()
}

export const roundNumber = (num: number, decimalPlaces: number) => {
  const factor = Math.pow(10, decimalPlaces)
  return Math.round(num * factor) / factor
}

/**
 * 加密图片路径中的文件名部分
 * @param src 图片原始URL
 * @returns 处理后的URL
 */
export const encryptImagePath = (src: string): string => {
  // 匹配web/后的文件名部分(包括中文编码)
  const regex = /(web\/)([^?]+)(\?.*)?/
  const match = src.match(regex)
  if (!match) return src // 如果不匹配则返回原URL
  const [_, prefix, filename, query] = match
  let url = signFun('web/' + filename)
  // 重新组合URL
  return url
}

/**
 * 使用正则表达式提取并更新HTML字符串中的所有src属性
 * @param htmlString 要处理的HTML字符串
 * @param callback 处理src的回调函数，接收原始src并返回新的src
 * @returns 处理后的HTML字符串
 */
export function updateAllSrcAttributes(
  htmlString: string,
  callback: (src: string) => string
): string {
  // 匹配所有src属性的正则表达式
  const srcRegex = /src=["']([^"']+)["']/g

  // 替换所有匹配的src属性
  return htmlString.replace(srcRegex, (match, srcValue) => {
    const newSrc = callback(srcValue)
    return `src="${newSrc}"`
  })
}
export default {
  email,
  accountNumber,
  passWord,
  mobile,
  url,
  date,
  dateISO,
  number,
  digits,
  idCard,
  carNo,
  amount,
  chinese,
  letter,
  enOrNum,
  contains,
  range,
  rangeLength,
  empty,
  isEmpty: empty,
  jsonString,
  landline,
  object,
  array,
  code,
  onlyNumber,
  getFileType,
  filterTime,
  filterDataTime,
  getUrlParameter,
  getUrlName,
  handleDate
}
